import themeChangeBehavior from 'tdesign-miniprogram/mixins/theme-change';
const pagePermissionMixin = require('../../utils/page-permission-mixin.js');
const { MODULES } = require('../../utils/permission.js');
const { getProductProcessList, submitWorkEntry } = require('../../utils/piecework-entry-api.js');
const { smartCache, trackPagePerformance, debounce } = require('../../utils/performance-monitor.js');

Page({
  behaviors: [themeChangeBehavior],
  
  // 混入权限检查方法
  ...pagePermissionMixin,
  
  data: {
    userInfo: null,
    formData: {
      productionDate: new Date().toISOString().split('T')[0]
    },
    productList: [],
    filteredProductList: [], // 过滤后的产品列表
    selectedProduct: {},
    selectedProcessList: [], // 多选工序列表，每个元素包含工序信息和数量
    showNotice: true,
    totalAmount: '0.00', // 总金额
    canSave: false,
    loading: false,
    showProcessModal: false,
    processList: [],
    imageLoadError: false, // 图片加载错误状态
    searchKeyword: '', // 搜索关键词
    batchQuantity: '', // 批量数量输入
    // 新增优化相关状态
    showSkeleton: true, // 骨架屏状态
    isFirstLoad: true, // 首次加载标识
    lastUpdateTime: 0, // 最后更新时间
    renderStage: 'skeleton' // 渲染阶段：skeleton -> loading -> ready
  },

  onLoad() {
    // 启动性能监控
    this.perfTracker = trackPagePerformance('piecework-entry');
    
    // 立即显示骨架屏，给用户反馈
    this.setData({ 
      renderStage: 'skeleton',
      showSkeleton: true 
    });
    
    // 检查页面权限
    this.onPageLoadPermissionCheck(MODULES.PIECEWORK_ENTRY);
    
    // 分阶段加载：先加载关键数据
    this.loadEssentialData();
  },

  onReady() {
    // 页面首次渲染完成后，加载次要数据
    setTimeout(() => {
      this.loadSecondaryData();
    }, 100);
  },

  onShow() {
    // 智能刷新策略
    this.smartRefresh();
  },

  // 分阶段加载：关键数据优先
  async loadEssentialData() {
    try {
      // 先加载用户信息（最重要）
      this.loadUserInfo();
      
      // 然后加载产品列表（核心功能）
      await this.loadProductProcessList();
      
      // 关键数据加载完成，切换到就绪状态
      this.setData({
        renderStage: 'ready',
        showSkeleton: false,
        isFirstLoad: false,
        lastUpdateTime: Date.now()
      });
      
      // 记录页面加载完成
      this.perfTracker.markReady();
      
    } catch (error) {
      console.error('关键数据加载失败:', error);
      this.setData({
        renderStage: 'error',
        showSkeleton: false
      });
      
      // 即使失败也要记录加载时间
      this.perfTracker.markReady();
    }
  },

  // 次要数据延迟加载
  loadSecondaryData() {
    // 预加载下一步可能需要的数据
    // 例如：常用工序数据、用户偏好设置等
    this.preloadFrequentData();
  },

  // 智能刷新策略
  smartRefresh() {
    const { isFirstLoad, lastUpdateTime } = this.data;
    const now = Date.now();
    
    // 首次加载跳过
    if (isFirstLoad) {
      return;
    }
    
    // 检查用户信息是否有更新
    const currentUserInfo = wx.getStorageSync('userInfo');
    if (currentUserInfo && JSON.stringify(currentUserInfo) !== JSON.stringify(this.data.userInfo)) {
      this.setData({ userInfo: currentUserInfo });
    }
    
    // 如果数据太旧（超过5分钟），刷新数据
    if (now - lastUpdateTime > 5 * 60 * 1000) {
      this.refreshData();
    }
  },

  // 刷新数据
  async refreshData() {
    // 显示loading，但不显示骨架屏
    this.setData({ loading: true });
    
    try {
      await this.loadProductProcessList();
      this.setData({ 
        loading: false,
        lastUpdateTime: Date.now()
      });
    } catch (error) {
      this.setData({ loading: false });
      wx.showToast({
        title: '数据更新失败',
        icon: 'none'
      });
    }
  },

  // 预加载常用数据
  preloadFrequentData() {
    // 预加载用户常用工序
    const frequentProcesses = wx.getStorageSync('frequent_processes') || [];

  },

  // 记录产品图片信息（移除预加载功能）
  logProductImages(products) {
    const imageUrls = products
      .filter(product => product.image)
      .map(product => product.image);
    

  },

  onUnload() {
    // 清理定时器，防止内存泄漏
    if (this.searchTimer) {
      clearTimeout(this.searchTimer);
      this.searchTimer = null;
    }
  },

  loadUserInfo() {
    const userInfo = wx.getStorageSync('userInfo') || { name: '系统管理员', account: '001' };
    this.setData({ userInfo });
  },

  async loadProductProcessList() {
    const cacheKey = 'product_process_list';
    
    // 使用智能缓存
    const cachedData = smartCache.get(cacheKey);
    if (cachedData) {
      this.processProductData(cachedData);
      return;
    }
    
    this.setData({ loading: true });
    
    try {
      const result = await getProductProcessList();
      
      if (result.message == "操作成功") {
        // 缓存数据，5分钟有效期
        smartCache.set(cacheKey, result.data, 5 * 60 * 1000);
        
        this.processProductData(result.data);
      } else {
        wx.showToast({
          title: result.message,
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('网络请求失败:', error);
      
      // 尝试获取过期缓存作为降级方案
      try {
        const expiredCache = wx.getStorageSync('smart_cache_product_process_list');
        if (expiredCache && expiredCache.data) {
          this.processProductData(expiredCache.data);
          wx.showToast({
            title: '使用本地数据，请稍后刷新',
            icon: 'none',
            duration: 3000
          });
          return;
        }
      } catch (cacheError) {
        console.error('读取过期缓存失败:', cacheError);
      }
      
      wx.showToast({
        title: '加载产品列表失败',
        icon: 'none'
      });
    } finally {
      this.setData({ loading: false });
    }
  },

  // 处理产品数据（分离出来提高可维护性）
  processProductData(data) {
    // 格式化产品列表数据（使用productCode作为主键，性能更好）
    const productList = data.map(product => {
      // 调试信息：记录图片URL

      
      return {
        productCode: product.productCode,
        productName: product.productName,
        image: product.image,
        processList: product.processList || []
      };
    });
    
    // 为第一个产品的工序列表添加选中状态
    const firstProduct = productList[0] || {};
    const processList = (firstProduct.processList || []).map(process => ({
      ...process,
      selected: false
    }));

    this.setData({ 
      productList,
      filteredProductList: productList, // 初始化过滤后的列表
      selectedProduct: firstProduct,
      processList: processList
    });
    
    // 如果第一个产品有图片，检查图片可用性
    if (firstProduct.image) {
      this.checkImageAvailability(firstProduct.image);
    }
    
    // 记录产品图片信息，改为按需加载
    this.logProductImages(productList);
  },

  // 选择产品
  onSelectProduct(e) {
    const { product } = e.currentTarget.dataset;
    
    // 为工序列表添加选中状态
    const processList = (product.processList || []).map(process => ({
      ...process,
      selected: false
    }));
    
    // 重置图片加载状态，准备加载新产品图片
    this.setData({
      selectedProduct: product,
      processList: processList,
      selectedProcessList: [], // 清空已选工序列表
      totalAmount: '0.00',
      imageLoadError: false // 重置图片加载错误状态
    });
    
    // 如果有图片URL，预检查图片可用性
    if (product.image) {
      this.checkImageAvailability(product.image);
    }
    
    this.checkCanSave();
  },

  // 显示工序选择弹窗
  showProcessSelector() {
    if (!this.data.selectedProduct.productCode) {
      wx.showToast({
        title: '请先选择产品',
        icon: 'none'
      });
      return;
    }
    
    this.setData({ showProcessModal: true });
  },

  // 选择工序（多选 - 优化性能）
  onSelectProcess(e) {
    const { process } = e.currentTarget.dataset;
    const { selectedProcessList, processList } = this.data;
    
    // 检查工序是否已选中
    const existingIndex = selectedProcessList.findIndex(item => 
      item.processCode === process.processCode
    );
    
    let newSelectedList, newProcessList;
    
    if (existingIndex >= 0) {
      // 如果已选中，则移除
      newSelectedList = selectedProcessList.filter((_, index) => index !== existingIndex);
    } else {
      // 如果未选中，则添加（默认数量为空，等待用户输入）
      newSelectedList = [...selectedProcessList, {
        processCode: process.processCode,
        processName: process.processName,
        price: process.price || '0',
        description: process.description || '',
        quantity: '',
        amount: '0.00'
      }];
    }
    
    // 批量更新：只更新变化的工序选中状态
    newProcessList = processList.map(item => {
      if (item.processCode === process.processCode) {
        return { ...item, selected: existingIndex < 0 };
      }
      return item;
    });
    
    // 计算新的总金额
    const newTotalAmount = this.calculateTotalAmountValue(newSelectedList);
    const canSave = this.checkCanSaveValue(newSelectedList);
    
    // 一次性更新所有状态
    this.setData({
      selectedProcessList: newSelectedList,
      processList: newProcessList,
      totalAmount: newTotalAmount,
      canSave: canSave
    });
  },

  // 关闭工序选择弹窗
  closeProcessModal() {
    this.setData({ showProcessModal: false });
  },

  // 隐藏提示条
  hideNotice() {
    this.setData({
      showNotice: false
    });
  },

  // 日期选择
  onDateChange(e) {
    this.setData({
      'formData.productionDate': e.detail.value
    });
  },

  // 工序数量输入（优化性能，减少setData调用）
  onProcessQuantityInput(e) {
    const { processCode } = e.currentTarget.dataset;
    const quantity = e.detail.value;
    const { selectedProcessList } = this.data;
    
    // 找到对应的工序并更新数量
    const processIndex = selectedProcessList.findIndex(item => 
      item.processCode === processCode
    );
    
    if (processIndex >= 0) {
      // 创建新的列表副本，避免直接修改原数据
      const newSelectedProcessList = [...selectedProcessList];
      newSelectedProcessList[processIndex] = { ...selectedProcessList[processIndex] };
      
      newSelectedProcessList[processIndex].quantity = quantity;
      
      // 重新计算该工序的金额
      const price = parseFloat(newSelectedProcessList[processIndex].price) || 0;
      const qty = parseFloat(quantity) || 0;
      newSelectedProcessList[processIndex].amount = (price * qty).toFixed(2);
      
      // 计算新的总金额和保存状态
      const newTotalAmount = this.calculateTotalAmountValue(newSelectedProcessList);
      const canSave = this.checkCanSaveValue(newSelectedProcessList);
      
      // 一次性更新所有状态
      this.setData({
        selectedProcessList: newSelectedProcessList,
        totalAmount: newTotalAmount,
        canSave: canSave
      });
    }
  },

  // 删除选中的工序（优化性能）
  removeSelectedProcess(e) {
    const { processCode } = e.currentTarget.dataset;
    const { selectedProcessList, processList } = this.data;
    
    const newSelectedList = selectedProcessList.filter(item => 
      item.processCode !== processCode
    );
    
    // 更新processList中对应工序的选中状态
    const updatedProcessList = processList.map(item => ({
      ...item,
      selected: item.processCode === processCode ? false : item.selected
    }));
    
    // 计算新的总金额和保存状态
    const newTotalAmount = this.calculateTotalAmountValue(newSelectedList);
    const canSave = this.checkCanSaveValue(newSelectedList);
    
    // 一次性更新所有状态
    this.setData({
      selectedProcessList: newSelectedList,
      processList: updatedProcessList,
      totalAmount: newTotalAmount,
      canSave: canSave
    });
  },

  // 日期选择（保留兼容性）
  onDateChange(e) {
    this.setData({
      'formData.productionDate': e.detail.value
    });
  },

  // 计算总金额（纯函数版本，性能优化）
  calculateTotalAmountValue(selectedProcessList) {
    let total = 0;
    selectedProcessList.forEach(process => {
      const amount = parseFloat(process.amount) || 0;
      total += amount;
    });
    return total.toFixed(2);
  },

  // 计算总金额（带setData版本）
  calculateTotalAmount() {
    const newTotalAmount = this.calculateTotalAmountValue(this.data.selectedProcessList);
    this.setData({
      totalAmount: newTotalAmount
    });
  },

  // 检查是否可以保存（纯函数版本，性能优化）
  checkCanSaveValue(selectedProcessList, selectedProduct = this.data.selectedProduct) {
    // 检查是否选择了产品
    if (!selectedProduct.productCode) {
      return false;
    }
    
    // 检查是否至少选择了一个工序且有有效数量
    return selectedProcessList.some(process => 
      process.quantity && parseFloat(process.quantity) > 0
    );
  },

  // 检查是否可以保存（带setData版本）
  checkCanSave() {
    const canSave = this.checkCanSaveValue(this.data.selectedProcessList);
    this.setData({ canSave });
  },

  // 验证表单
  validateForm() {
    const { selectedProduct, selectedProcessList, userInfo } = this.data;

    if (!selectedProduct.productCode) {
      wx.showToast({ title: '请选择产品', icon: 'none' });
      return false;
    }

    if (selectedProcessList.length === 0) {
      wx.showToast({ title: '请选择至少一个工序', icon: 'none' });
      return false;
    }

    // 检查是否所有选中的工序都有有效数量
    const invalidProcess = selectedProcessList.find(process => 
      !process.quantity || parseFloat(process.quantity) <= 0
    );
    
    if (invalidProcess) {
      wx.showToast({ 
        title: `请为工序 ${invalidProcess.processName} 输入有效的数量`, 
        icon: 'none' 
      });
      return false;
    }

    if (!userInfo.name || !userInfo.employeeNumber) {
      wx.showToast({ title: '用户信息不完整', icon: 'none' });
      return false;
    }

    return true;
  },

  // 保存记录（批量）
  async onSave() {
    if (!this.validateForm()) {
      return;
    }

    const { selectedProduct, selectedProcessList, userInfo } = this.data;

    wx.showLoading({
      title: '保存中...'
    });

    try {
      // 构建多个录入数据
      const entryPromises = selectedProcessList.map(process => {
        const entryData = {
          productCode: selectedProduct.productCode,
          productName: selectedProduct.productName,
          processCode: String(process.processCode),
          processName: process.processName,
          quantity: String(process.quantity),
          price: String(process.price || '0'),
          employeeNumber: String(userInfo.employeeNumber || ''),
          employeeName: String(userInfo.name || '')
        };

        return submitWorkEntry(entryData);
      });

      // 等待所有记录保存完成
      const results = await Promise.all(entryPromises);

      wx.hideLoading();

      // 检查所有结果
      const failedResults = results.filter(result => !result.message == "操作成功");
      
      if (failedResults.length === 0) {
        wx.showToast({
          title: `成功保存${selectedProcessList.length}条记录`,
          icon: 'success'
        });

        // 重置表单
        this.resetForm();
      } else {
        const successCount = results.length - failedResults.length;
        wx.showToast({
          title: `成功保存${successCount}条，失败${failedResults.length}条`,
          icon: 'none',
          duration: 3000
        });
      }
    } catch (error) {
      wx.hideLoading();

      wx.showToast({
        title: '保存失败',
        icon: 'none'
      });
    }
  },

  // 重置表单
  resetForm() {
    this.setData({
      selectedProcessList: [],
      totalAmount: '0.00',
      canSave: false,
      batchQuantity: '' // 清空批量数量
    });
  },

  // 返回上一页（返回到今日录入页面）
  navigateBack() {
    wx.redirectTo({
      url: '/pages/piecework-today/piecework-today?from=piecework-entry'
    });
  },

  // 返回申报列表
  goBackToTodayList() {
    wx.redirectTo({
      url: '/pages/piecework-today/piecework-today?from=piecework-entry'
    });
  },

  // 下拉刷新
  async onPullDownRefresh() {
    await this.loadProductProcessList();
    wx.stopPullDownRefresh();
  },

  // 跳转到今日录入列表
  goToTodayList() {
    wx.navigateTo({
      url: '/pages/piecework-today/piecework-today?from=piecework-entry'
    });
  },

  // 检查图片可用性
  checkImageAvailability(imageUrl) {
    // 基本URL格式检查
    if (!imageUrl || typeof imageUrl !== 'string') {
      this.setData({ imageLoadError: true });
      return;
    }
    
    // 检查是否是有效的图片URL格式
    const imageExtensions = /\.(jpg|jpeg|png|gif|bmp|webp)$/i;
    const isValidImageUrl = imageUrl.startsWith('http') || imageUrl.startsWith('https') || imageExtensions.test(imageUrl);
    
    if (!isValidImageUrl) {
      console.warn('Invalid image URL format:', imageUrl);
      this.setData({ imageLoadError: true });
    }
  },

  // 图片加载成功
  onImageLoad(e) {
    this.setData({
      imageLoadError: false
    });
  },

  // 图片加载失败
  onImageError(e) {
    console.error('图片加载失败:', e.detail, '图片URL:', this.data.selectedProduct.image);
    
    this.setData({
      imageLoadError: true
    });
    
    // 只在用户主动操作时显示错误提示，避免过多干扰
    wx.showToast({
      title: '图片暂时无法显示',
      icon: 'none',
      duration: 2000
    });
  },

  // 重试加载图片
  retryLoadImage(e) {
    e.stopPropagation(); // 阻止事件冒泡，避免触发预览
    
    const { selectedProduct } = this.data;
    if (!selectedProduct.image) {
      return;
    }

    
    // 重置错误状态
    this.setData({
      imageLoadError: false
    });
    
    // 显示重试提示
    wx.showToast({
      title: '重新加载中...',
      icon: 'loading',
      duration: 1500
    });
  },

  // 预览图片
  previewImage() {
    const { selectedProduct, imageLoadError } = this.data;
    
    if (!selectedProduct.image) {
      wx.showToast({
        title: '暂无图片',
        icon: 'none'
      });
      return;
    }
    
    if (imageLoadError) {
      wx.showToast({
        title: '图片无法预览',
        icon: 'none'
      });
      return;
    }
    
    wx.previewImage({
      urls: [selectedProduct.image],
      current: selectedProduct.image,
      fail: (err) => {
        console.error('图片预览失败:', err);
        wx.showToast({
          title: '图片预览失败',
          icon: 'none'
        });
      }
    });
  },

  // 搜索输入处理（使用防抖优化）
  onSearchInput: debounce(function(e) {
    const searchKeyword = e.detail.value;
    
    // 只在搜索词实际变化时才更新
    if (this.data.searchKeyword !== searchKeyword) {
      
      this.setData({
        searchKeyword
      }, () => {
        this.filterProducts(searchKeyword);
      });
    }
  }, 300),

  // 搜索确认
  onSearchConfirm(e) {
    const searchKeyword = e.detail.value;
    this.filterProducts(searchKeyword);
  },

  // 清除搜索
  clearSearch() {
    this.setData({
      searchKeyword: ''
    });
    this.filterProducts('');
  },

  // 过滤产品
  filterProducts(keyword = '') {
    const { productList } = this.data;
    
    if (!keyword.trim()) {
      // 如果没有关键词，显示所有产品
      this.setData({
        filteredProductList: productList
      });
      return;
    }
    
    // 转换为小写进行模糊匹配
    const lowerKeyword = keyword.toLowerCase().trim();
    
    const filteredList = productList.filter(product => {
      // 搜索产品名称或产品编码
      const productNameMatch = product.productName && 
        product.productName.toLowerCase().includes(lowerKeyword);
      const productCodeMatch = product.productCode && 
        product.productCode.toLowerCase().includes(lowerKeyword);
      
      return productNameMatch || productCodeMatch;
    });
    
    this.setData({
      filteredProductList: filteredList
    });
  },

  // 批量数量输入处理
  onBatchQuantityInput(e) {
    const batchQuantity = e.detail.value;
    this.setData({
      batchQuantity: batchQuantity
    });
  },

  // 应用批量数量到所有选中工序
  applyBatchQuantity() {
    const { batchQuantity, selectedProcessList } = this.data;
    
    if (!batchQuantity || parseFloat(batchQuantity) <= 0) {
      wx.showToast({
        title: '请输入有效的数量',
        icon: 'none'
      });
      return;
    }

    if (selectedProcessList.length === 0) {
      wx.showToast({
        title: '请先选择工序',
        icon: 'none'
      });
      return;
    }

    // 为所有选中工序应用相同数量
    const newSelectedProcessList = selectedProcessList.map(process => {
      const price = parseFloat(process.price) || 0;
      const qty = parseFloat(batchQuantity) || 0;
      
      return {
        ...process,
        quantity: batchQuantity,
        amount: (price * qty).toFixed(2)
      };
    });

    // 计算新的总金额和保存状态
    const newTotalAmount = this.calculateTotalAmountValue(newSelectedProcessList);
    const canSave = this.checkCanSaveValue(newSelectedProcessList);

    // 一次性更新所有状态
    this.setData({
      selectedProcessList: newSelectedProcessList,
      totalAmount: newTotalAmount,
      canSave: canSave
    });

    wx.showToast({
      title: `已为${selectedProcessList.length}个工序应用数量`,
      icon: 'success',
      duration: 2000
    });
  }
}); 